home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 002 / roff4.arc / ROFF42.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-08-10  |  11.0 KB  |  384 lines
  1. /********************************************************/
  2. /*                                                      */
  3. /*                  ROFF4, Version 1.60                 */
  4. /*                                                      */
  5. /*(C) 1983,4 by Ernest E. Bergmann                      */
  6. /*              Physics, Building #16                   */
  7. /*              Lehigh Univerisity                      */
  8. /*              Bethlehem, Pa. 18015                    */
  9. /*                                                      */
  10. /* Permission is hereby granted for all commercial and  */
  11. /* non-commercial reproduction and distribution of this */
  12. /* material provided this notice is included.           */
  13. /*                                                      */
  14. /********************************************************/
  15. /*feb 19, 1984*/
  16. /*Jan 14, 1984*/
  17. #include "roff4.h"
  18.  
  19. insert()        /*takes a command line in LINE and adds its
  20.                 entry to the table; no space check is made of
  21.                 TRTBL*/
  22. {
  23.       int *pw;
  24.       char *pc,*s2,*s3,*fnd,*find2();
  25.       pw=(int *) TREND;
  26.       *pw=SLINK;
  27.       pc=(char *) (pw+1);
  28.       gettl3(LINE,pc,&s2,&s3);
  29.       if(fnd=find2(pc,SLINK))
  30.       {
  31.             fprintf(STDERR,"%cWarning: <%s> was defined to be <%s>\n",
  32.                         BELL,pc,fnd);
  33.             fprintf(STDERR,"...now it is defined to be <%s>\n",s2);
  34.       }
  35.       SLINK=(int *)TREND;
  36.       TREND=s3;
  37. }
  38. /****************************************/
  39. showit()        /* displays the list of entries in the string
  40.                 substitution table pointed to by HEAD. */
  41. {
  42.       int *pw;
  43.       char *pc;
  44.       fprintf(STDERR,"ENTRIES:\n");
  45.       pw=SLINK;
  46.       while(pw)
  47.       {
  48.             fprintf(STDERR,"%u: ",pw);
  49.             pc=(char *)(pw+1);
  50.             fprintf(STDERR,"<%s>",pc);
  51.             pc += strlen(pc); 
  52.             pc++;
  53.             if(*pc) fprintf(STDERR," <%s>\n",pc);
  54.             else fprintf(STDERR," <>\n"); /*'C' bug*/
  55.             pw=(int *) *pw;
  56.       }
  57.       dashes();
  58. }
  59. /****************************************/
  60. putback(c)      /*cf K & P, p256*/
  61. char c;
  62. {
  63.       if(++BINP >= BACKSIZE)
  64.       {
  65.             printf(STDERR,"Too many characters pushed back\n");
  66.             exit();
  67.       }
  68.       BACKBUF[BINP]=c;
  69. }
  70. /****************************************/
  71. int ngetc(iobuf)        /*cf K & P p256*/
  72. FILE *iobuf;     /*filters \r followed by \n,msb*/
  73. {
  74.       int kgetc();
  75.       int c;
  76.       if(BINP) c=BACKBUF[BINP];
  77.       else    {
  78.             if(KEYBD) c=kgetc();
  79.             else
  80.                 if ((c=getc(iobuf))!=EOF) c &= 0x7f;
  81.             BACKBUF[BINP=1]=c;
  82.       }
  83.       if((c!=EOF)) BINP--;
  84.       if(c=='\r')
  85.       {
  86.             c=ngetc(iobuf);
  87.             if(c!='\n')
  88.             {
  89.                   putback(c);
  90.                   return('\r');
  91.             }
  92.       }
  93.       return(c);
  94. }
  95. /****************************************/
  96. char kgetc()    /*like getc(),from keyboard, line-buffered*/
  97. {
  98.       int i;
  99.       if(!*KPTR)
  100.       {
  101.             fprintf(STDERR,"%c",KEYBD);
  102.             fflush(STDERR);
  103.             if (gets(KLINE)==NULL) return(EOF);
  104.             i=strlen(KLINE);
  105.             KLINE[i++]='\n';
  106.             KLINE[i]='\0';
  107.             KPTR=KLINE;
  108.       }
  109.       return(*(KPTR++));
  110. }
  111. /** add by Conrad Kwok. 9th Sept.,84 ****/
  112. pbmac(s,sl)
  113. char s[],sl[];
  114. { 
  115.       char *parms[10],dupln[LSZ];
  116.       int i;
  117.       strcpy(dupln,sl);
  118.       setparm(dupln,parms);
  119.       for (i=strlen(s)-1;i>=0;)
  120.             if (isdigit(s[i]))
  121.                   if (i>0 && s[i-1]=='$')
  122.                   /*
  123.                           if (parms[s[i] & 0x0f]=='\0')
  124.                           { fprintf(STDERR,
  125.                              "not sufficient parameters in this line\n%s\n",sl);
  126.                             exit();
  127.                           }
  128.                           else
  129.                         */
  130.                   { 
  131.                         pbstr(parms[s[i--] & 0x0f]); 
  132.                         --i;
  133.                   }
  134.                   else
  135.                         putback(s[i--]);     
  136.             else
  137.                   putback(s[i--]);
  138. }
  139. setparm(sl,parms)
  140. char *sl,*parms[];
  141. { 
  142.       char a,c;
  143.       int nuparm;
  144.       for (c=*sl;c!=' ' && c!='\n' && c!='\t';)c=*++sl;
  145.       while (c==' ' || c=='\t')
  146.             c=*++sl;
  147.       for (nuparm=0;nuparm<10;) {
  148.             if (!(isalnum(c) || (c=='+') || (c=='-')))
  149.                   sl++;
  150.             else
  151.                   c=' ';
  152.             parms[nuparm++]=sl;
  153.             for (a=*sl;a!=c && a!='\n' && a!='\0';)
  154.                   if (c==' ' && a=='\t') break;
  155.             else a=*++sl;
  156.             *sl='\0';
  157.             c=a;
  158.             if (a!='\0' && a!='\n') while (c==' ' || c=='\t') c=*++sl;
  159.       }
  160. }
  161. /****************************************/
  162. pbstr(s)        /*put back string on input;cf K&P,p257*/
  163. char s[LSZ];
  164. {
  165.       int i;
  166.       for(i=strlen(s);i>0;) putback(s[--i]);
  167. }
  168. /****************************************/
  169. minsert()       /*takes a .DM and following lines and places
  170.                 the information in the table;  no macro
  171.                 definition nesting permitted*/
  172. {
  173.       char c, *pc,*pc2;
  174.       int *pw1;
  175.       /*pass over command and following white space*/
  176.       for(pc=LINE,c=*pc; (c!=' ')&&(c!='\n')&&(c!='\t'); pc++)
  177.             c=*pc;
  178.       for(; (c==' ')||(c=='\t'); pc++) c=*pc;
  179.       start();
  180.       if(c=='\n') {
  181.             fprintf(STDERR,".DM is UNnamed\n"); 
  182.       }
  183.       else    {
  184.             pw1=(int *)TREND;
  185.             *(pw1++)=MLINK;
  186.             MLINK=(int *)TREND;
  187.             TREND=(char *) pw1;
  188.             while(class(c)==BLACK)
  189.             {
  190.                   *(TREND++)=c;
  191.                   c=*(pc++);
  192.             }
  193.       }
  194.       *(TREND++)='\0';
  195.       while(fgets2(LINE,IOBUF))       /*until EOF*/
  196.       {
  197.             pw1=(int *)LINE;
  198.             if((*LINE==COMMAND)&&(comtyp(LINE)==EM)) break;
  199.             else    {
  200.                   transfer(&pw1,&TREND,0);
  201.                   *(TREND-1)='\n';
  202.             }
  203.       }
  204.       *(TREND++)='\0';
  205.       complete();
  206. }
  207. /****************************************/
  208. showm() /*lists macro definitions*/
  209. {
  210.       int *pw;
  211.       char *pc;
  212.       fprintf(STDERR,"MACROS DEFINED:\n");
  213.       pw=MLINK;
  214.       while(pw)
  215.       {
  216.             pc =(char *) (pw+1);
  217.             fprintf(STDERR,"%u  .%s\n",pw,pc);
  218.             pc +=strlen(pc); 
  219.             pc++;
  220.             fprintf(STDERR,"%s\n",pc);
  221.             pw=(int *)*pw;
  222.       }
  223.       dashes();
  224. }
  225. /****************************************/
  226. char *macq(line)        /*looks up name to see if it is a macro
  227.                         definition.  If it is, returns the
  228.                         corresponding string, else returns
  229.                         FALSE.
  230.                         */
  231. char *line;
  232. {
  233.       char c,*pc,wb[LSZ],*find2();
  234.       pc=wb;
  235.       while(class(c=*(++line))==BLACK) *(pc++)=c;
  236.       *pc='\0';
  237.       return(find2(wb,MLINK));
  238. }
  239. /****************************************/
  240. char *find2(s,link)     /*finds or doesn't find s in table
  241.                         of substitutions pointed to by link*/
  242. char *s;
  243. int *link;
  244. {
  245.       char *pc;
  246.       while(link)
  247.       {
  248.             if(!strcmp(s,link+1))
  249.             {
  250.                   pc=(char *) (link+1);
  251.                   pc += strlen(pc);
  252.                   pc++;
  253.                   return(pc);
  254.             }
  255.             link=(int *) *link;
  256.       }
  257.       return(FALSE);
  258. }
  259. /****************************************/
  260. /*from ndio.c*/
  261. #define CON_INPUT 1                     /* BDOS call to read console       */
  262. #define CON_OUTPUT 2                    /* BDOS call to write to console   */
  263. #define CON_STATUS 11                   /* BDOS call to interrogate status */
  264.  
  265. #define CONTROL_C 3                     /* Quit character                  */
  266. #define INPIPE 2                        /* bit setting to indicate directed
  267. input from a temp. pipe fil     */
  268. #define VERBOSE 2                       /* bit setting to indicate output is to
  269.                                            go to console AND directed output */
  270. #define DIRECTED_OUT 1
  271. #define CONS_TOO 2
  272. #define CPM_LIST_OUT 4
  273. #define PRINTER_OUT 8
  274. #define ROBOTYPE_OUT 16
  275. #define CONSOLE_ONLY 0
  276.  
  277. /* 
  278.         The "dioinit" function must be called at the beginning of the
  279.         "main" function:
  280. */
  281.  
  282. dioflush()
  283. {
  284.       if (_doflag & DIRECTED_OUT)
  285.       {
  286.             putc(0x1a,_dobuf);
  287.             fflush(_dobuf);
  288.             fclose(_dobuf);
  289.       }
  290. }
  291.  
  292. /*
  293.         This version of "putchar" replaces the regular version when using
  294.         directed I/O:
  295. */
  296.  
  297. putchar(c)
  298. char c;
  299. {       
  300.       if (SUPPRESS) return;
  301.       if (LASTCH!='\r' || c!='\r') {
  302.             if (_doflag & DIRECTED_OUT)
  303.             {
  304.                   /* if (c == '\n') putc('\r',_dobuf); */ /*3rd Mar,85   KKP*/
  305.                   if(putc(c,_dobuf) == ERROR)
  306.                   {
  307.                         fprintf(STDERR,"File output error; disk full?\n");
  308.                         exit();
  309.                   }
  310.             }
  311.  
  312.             if (_doflag==0 || _doflag & CONS_TOO)
  313.             {
  314.                   bdos(CON_STATUS);
  315.                   if (c == '\n') bdos(CON_OUTPUT,'\r');
  316.                   bdos(CON_OUTPUT,c);
  317.             }
  318.  
  319.             if (_doflag & CPM_LIST_OUT)
  320.             {
  321.                   /* if (c=='\n') bdos(5,'\r'); */ /*3rd Mar,85 KKP */
  322.                   bdos(5,c);
  323.             }
  324.             LASTCH=c;    /* 5th Mar,85   KKP */
  325.       }
  326. }
  327. /****************************************/
  328. #define argc *argcp
  329. dioinit(argcp,argv)
  330. int *argcp;
  331. char **argv;
  332. {
  333.       int i,j, argcount;
  334.       int n;  /* this keeps track of location in argument */
  335.  
  336.       _doflag = FALSE;  /* No directed /O by default   */
  337.       _nullpos = &argv[argc];
  338.       argcount = 1;
  339.  
  340.       for (i = 1; i < argc; i++)      /* Scan the command line for > and )*/
  341.       {
  342.             n=0;    /* start with first character */
  343. getmore:        
  344.             switch(argv[i][n++]) {
  345.  
  346.             case '+': 
  347.                   _doflag |= VERBOSE;
  348.                   goto getmore;
  349.             case ')':
  350.                   _doflag |= CPM_LIST_OUT;
  351.                   goto getmore;
  352.  
  353. foo:   
  354.             case '&':/*Check for directed output*/
  355.                   if (!argv[i][n]) 
  356.                   {
  357.                         fprintf(STDERR,"Bad redirection specifier\n");
  358.                         exit();
  359.                   }
  360.                   strcpy (sav_out_file, &argv[i][n] );
  361.                   if ((_dobuf=fopen(sav_out_file, "w")) == NULL)
  362.                   {
  363.                         fprintf(STDERR,"\nCan't create <%s>\n",
  364.                         sav_out_file);
  365.                         exit();
  366.                   }
  367.                   _doflag++;
  368.  
  369. movargv:   
  370.                   argc = argcount;
  371.                   argv[argc] = 0;
  372.                   break;
  373.  
  374.             default:    /* handle normal arguments: */
  375.                   if (n!=1) goto movargv;
  376.                   argcount++;
  377.             }
  378.       }
  379. }
  380.  
  381.  
  382. #undef argc
  383.  
  384.